home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / BlankWin.C < prev    next >
C/C++ Source or Header  |  1990-12-05  |  9KB  |  433 lines
  1. //$BlankWin,BlankWindowStretcher,InspectCommand$
  2. #include "BlankWin.h"
  3. #include "Error.h"
  4. #include "WindowPort.h"
  5. #include "WindowSystem.h"
  6. #include "Menu.h"
  7. #include "ObjectTable.h"
  8. #include "ClassManager.h"
  9.  
  10. #include "FixedStorage.h"
  11. #include "Storage.h"
  12.  
  13. Token gToken;
  14. BlankWin *gWindow;
  15.  
  16. //---- InspectCommand ----------------------------------------------------------
  17.  
  18. class InspectCommand : public Command {
  19.     BlankWin *win;
  20.     VObject *newvop, *lastvop;
  21. public:
  22.     InspectCommand(BlankWin *bw)
  23.     { win= bw; lastvop= 0; }
  24.     void TrackFeedback(Point, Point, bool);
  25.     Command *TrackMouse(TrackPhase atp, Point, Point, Point np);
  26. };
  27.  
  28. void InspectCommand::TrackFeedback(Point, Point, bool)
  29. {
  30.     if (newvop != lastvop) {
  31.     if (lastvop)
  32.         GrInvertRect(lastvop->contentRect);
  33.     if (newvop)
  34.         GrInvertRect(newvop->contentRect);
  35.     lastvop= newvop;
  36.     }
  37. }
  38.  
  39. Command *InspectCommand::TrackMouse(TrackPhase atp, Point, Point, Point np)
  40. {
  41.     newvop= win->GetViewedVObject()->FindItem(np);
  42.     if (atp == eTrackRelease && newvop) {
  43.     VObject *v= newvop;
  44.     newvop= 0;
  45.     TrackFeedback(gPoint0, gPoint0, FALSE);
  46.     v->Inspect();
  47.     return gNoChanges;
  48.     }
  49.     return this;
  50. }
  51.  
  52. //---- BlankWin ----------------------------------------------------------------
  53.  
  54. MetaImpl(BlankWin, (TP(nexthandler), 0));
  55.  
  56. BlankWin::BlankWin(Point extent, BWinFlags f) : Clipper(0, extent)
  57. {
  58.     Init(0, eCrsBoldArrow, f);
  59. }
  60.  
  61. BlankWin::BlankWin(VObject *vp, Point extent, BWinFlags f, Ink *bg,
  62.                 GrCursor curs) : Clipper(vp, extent, cIdNone, bg)
  63. {
  64.     Init(0, curs, f);
  65. }
  66.  
  67. BlankWin::BlankWin(EvtHandler *eh, VObject *vp, Point extent, BWinFlags f)
  68.                             : Clipper(vp, extent)
  69. {
  70.     Init(eh, eCrsBoldArrow, f);
  71. }
  72.  
  73. void BlankWin::Init(EvtHandler *eh, GrCursor curs, BWinFlags f)
  74. {
  75.     nexthandler= eh;
  76.     ResetFlag(eVObjOpen);
  77.     SetFlag(f);
  78.     cursor= curs;
  79. }
  80.  
  81. BlankWin::~BlankWin()
  82. {
  83.     if (vop) {
  84.     // vop->FreeAll(); // Causes double delete,
  85.     // when called by ~Dialog, tom@izf.tno.nl
  86.     SafeDelete(vop);
  87.     }
  88.     if (portDesc) {
  89.     portDesc->Remove();     // mark as free
  90.     portDesc= 0;
  91.     }
  92. }
  93.  
  94. EvtHandler *BlankWin::GetNextHandler()
  95. {
  96.     return nexthandler;
  97. }
  98.  
  99. void BlankWin::InvalidateRect(Rectangle r)
  100. {
  101.     if (GetExtent() != gPoint_1)    // resize event pending; ignore 
  102.     MakePort()->InvalidateRect(r);
  103. }
  104.  
  105. void BlankWin::SetExtent(Point e)
  106. {
  107.     if (portDesc && (e != GetExtent())) {
  108.     contentRect.extent= gPoint_1;
  109.     portDesc->SetExtent(e);
  110.     }
  111. }
  112.  
  113. void BlankWin::SetOrigin(Point at)
  114. {
  115.     VObject::SetOrigin(gPoint0);
  116.     if (portDesc)
  117.     portDesc->SetOrigin(GetRect().origin+at);
  118. }
  119.  
  120. void BlankWin::SetFocus(Rectangle r, Point o)
  121. {
  122.     if (IsOpen() && portDesc) {
  123.     GrSetPort(portDesc);
  124.     GrSetClip(Inter(contentRect, r), o);
  125.     }
  126. }
  127.  
  128. void BlankWin::UpdateEvent()
  129. {
  130.     Rectangle r, *rp;
  131.     register int i, n;
  132.     
  133.     if (!IsOpen() || portDesc == 0 || portDesc->inval <= 0)
  134.     return;
  135.     GrSetPort(portDesc);
  136.     rp= portDesc->invalRects;
  137.     n= portDesc->inval;
  138.  
  139.     if (gBatch) {
  140.     for (i= n-1; i >= 0; i--) {
  141.         GrSetClip(Inter(contentRect, rp[i]), gPoint0);
  142.         GrSetPenNormal();
  143.         GrSetPattern(ePatBlack);
  144.         GrGiveHint(eHintBatch, sizeof(Rectangle), &rp[i]);
  145.         GrGiveHint(eHintTextBatch);
  146.         DrawAll(rp[i], FALSE);
  147.         GrGiveHint(eHintTextUnbatch);
  148.         GrGiveHint(eHintUnbatch);
  149.     }
  150.     } else {
  151.     GrGiveHint(eHintLock, sizeof(Rectangle), &portDesc->invalBounds);
  152.     for (i= n-1; i >= 0; i--) {
  153.         GrSetClip(Inter(contentRect, rp[i]), gPoint0);
  154.         GrSetPenNormal();
  155.         GrSetPattern(ePatBlack);
  156.         GrGiveHint(eHintTextBatch);
  157.         DrawAll(rp[i], FALSE);
  158.         GrGiveHint(eHintTextUnbatch);
  159.     }
  160.     GrGiveHint(eHintUnlock);
  161.     }
  162.     portDesc->inval= 0;
  163. }
  164.  
  165. void BlankWin::Update()
  166. {
  167.     SetContainer(0);
  168.     vop->CalcExtent();
  169.     vop->SetOrigin(gPoint0);
  170. }
  171.  
  172. void BlankWin::input(Token *t)
  173. {
  174.     if (! TestFlag(eBWinOverlay))
  175.     gWindow= this;
  176.     if (portDesc == 0)
  177.     return;
  178.     GrSetPort(portDesc);
  179.     
  180.     if (t->Code == eEvtDamage) {
  181.     if (t->Flags == eFlgDamage1) {
  182.         if (! IsOpen())
  183.         Clipper::Open(TRUE);
  184.         if (t->ext != GetExtent()) {
  185.         VObject::SetExtent(t->ext);
  186.         if (vop)
  187.             vop->SetContentRect(Rectangle(gPoint0, t->ext), TRUE);
  188.         }
  189.     }
  190.     } else {
  191.     gToken= *t;
  192.     
  193.     if ((t->Code == eEvtLeftButton) && !(t->Flags & eFlgButDown)
  194.                 && t->Flags == (eFlgShiftKey|eFlgMetaKey)) {
  195.         TrackInContent(gToken.Pos, gToken, new InspectCommand(this));
  196.         return;
  197.     }
  198.     if (t->IsKey() && t->Flags == (eFlgShiftKey|eFlgCntlKey|eFlgMetaKey)) {
  199.         switch (t->MapToAscii()) {
  200.         case 'q':           // emergency exit
  201.         Close();
  202.         break;
  203.         case 't':
  204.         Abort();
  205.         break;
  206.         case 'p':
  207.         Print();
  208.         break;
  209.         case 'v':
  210.         ObjectTable::VisitObjects();
  211.         break;
  212.         case 's':
  213.         gClassManager->InstanceStatistics();
  214.         break;
  215.         case 'i':
  216.         gClassManager->InstanceStatistics(TRUE);
  217.         break;
  218.         case 'e':
  219.         Error("input", "forced invocation of ErrorHandler");
  220.         break;
  221.         case 'w':
  222.         SetIgnoreLevel(0);
  223.         break;
  224.         case 'm':
  225.         MemPools::PrintStatistics();
  226.         break;
  227.         }
  228.         return;
  229.     }
  230.     PerformCommand(DispatchEvents(gToken.Pos, gToken, this));
  231.     }
  232.     UpdateEvent();
  233. }
  234.  
  235. Token BlankWin::ReadEvent(int timeout, bool overread)
  236. {
  237.     MakePort()->GetEvent(&gToken, timeout, overread);
  238.     return gToken;
  239. }
  240.  
  241. GrCursor BlankWin::GetCursor(Point)
  242. {
  243.     return cursor;
  244. }
  245.  
  246. class WindowPort *BlankWin::MakePort()
  247. {
  248.     if (portDesc == 0) {
  249.     portDesc= gWindowSystem->MakeWindow((InpHandlerFun) &BlankWin::input, this,
  250.             TestFlag(eBWinOverlay), TestFlag(eBWinBlock), FALSE);
  251.     portDesc->cursor= cursor;
  252.     }
  253.     return portDesc;
  254. }
  255.  
  256. void BlankWin::Open(bool mode)
  257. {
  258.     if (mode)
  259.     OpenAt(GetRect().origin);
  260.     else {
  261.     Clipper::Open(FALSE);
  262.     if (portDesc)
  263.         portDesc->Hide();
  264.     }
  265. }
  266.  
  267. void BlankWin::OpenAt(Point p, VObject *fp)
  268. {
  269.     WindowPort *fatherport= 0;
  270.     
  271.     MakePort();
  272.     
  273.     if (IsOpen()) {
  274.     MakePort()->Top();
  275.     return;
  276.     }
  277.     if (fp) {
  278.     fatherport= (WindowPort*) (fp->GetWindow()->portDesc);    
  279.     p= fp->GetPortPoint(p);
  280.     }
  281.  
  282.     GrSetPort(portDesc);
  283.  
  284.     if (vop)
  285.     vop->SetContainer(this);
  286.     Rectangle r(p, Max(GetMinSize().Extent(), GetExtent()));
  287.     contentRect.extent= gPoint_1;
  288.     portDesc->Show(fatherport, r);
  289.  
  290.     GrSetPort(fatherport);
  291. }
  292.  
  293. Command *BlankWin::DoLeftButtonDownCommand(Point, Token t, int)
  294. {
  295.     MakePort()->Top();
  296.     if (t.Flags & eFlgCntlKey)
  297.     return GetStretcher();
  298.     return GetMover();
  299. }
  300.  
  301. Rectangle BlankWin::ScreenRect()
  302. {
  303.     return gScreenRect - GetRect().origin;
  304. }
  305.  
  306. Rectangle BlankWin::GetRect()
  307. {
  308.     return MakePort()->GetRect();
  309. }
  310.  
  311. Command *BlankWin::GetMover()
  312. {
  313.     Command *wm= new VObjectMover(this, ScreenRect(), gPoint1, eCrsMoveHand, 4);
  314.     wm->SetFlag(eCmdFullScreen);
  315.     wm->ResetFlag(eCmdCanUndo);
  316.     return wm;
  317. }
  318.  
  319. Command *BlankWin::GetStretcher()
  320. {
  321.     if (TestFlag(eBWinFixed))
  322.     return gNoChanges;
  323.     return new BlankWindowStretcher(this, ScreenRect());
  324. }
  325.  
  326. void BlankWin::PushBackEvent(Token t)
  327. {
  328.     MakePort()->PushEvent(t);
  329. }
  330.  
  331. void BlankWin::Top()
  332. {
  333.     MakePort()->Top();
  334. }
  335.  
  336. void BlankWin::Bottom()
  337. {
  338.     MakePort()->Bottom();
  339. }
  340.  
  341. void BlankWin::Bell(long d)
  342. {
  343.     MakePort()->Bell(d);
  344. }
  345.  
  346. void BlankWin::SetMousePos(Point p)
  347. {
  348.     MakePort()->SetMousePos(p);
  349. }
  350.  
  351. void BlankWin::Grab(bool g, bool fs)
  352. {
  353.     MakePort()->Grab(g, fs);
  354. }
  355.  
  356. class Menu *BlankWin::GetMenu()
  357. {
  358.     return 0;
  359. }
  360.  
  361. void BlankWin::DoCreateMenu(Menu *mp)
  362. {
  363.     mp->AppendItems(
  364.     "collapse", cCOLLAPSE,
  365.     "top",      cTOP,
  366.     "bottom",   cBOTTOM,
  367.     "redisplay    ",cREDISPLAY,
  368.     0
  369.     );
  370. }
  371.  
  372. void BlankWin::DoSetupMenu(Menu *mp)
  373. {
  374.     if (TestFlag(eBWinBlock)) {
  375.     mp->EnableItem(cREDISPLAY);
  376.     return;
  377.     }
  378.     mp->EnableItems(cTOP, cREDISPLAY, cBOTTOM, cCOLLAPSE, 0);
  379.     Clipper::DoSetupMenu(mp);
  380. }
  381.  
  382. Command *BlankWin::DoMenuCommand(int cmd)
  383. {
  384.     switch (cmd) {
  385.     case cTOP:
  386.     MakePort()->Top();
  387.     break;
  388.     
  389.     case cBOTTOM:
  390.     MakePort()->Bottom();
  391.     break;
  392.     
  393.     case cREDISPLAY:
  394.     ForceRedraw();
  395.     break;
  396.     
  397.     default:
  398.     return Clipper::DoMenuCommand(cmd);
  399.     }
  400.     return gNoChanges;
  401. }
  402.  
  403. //---- BlankWindowStretcher ---------------------------------------------------------
  404.  
  405. BlankWindowStretcher::BlankWindowStretcher(BlankWin *w, Rectangle r)
  406.                             : VObjectStretcher(w, r)
  407. { 
  408.     SetFlag(eCmdFullScreen);
  409.     ResetFlag(eCmdCanUndo);
  410.     ddd= 0;
  411. }
  412.  
  413. void BlankWindowStretcher::TrackConstrain(Point ap, Point pp, Point *np)
  414. {
  415.     *np-= ddd;
  416.     VObjectStretcher::TrackConstrain(ap, pp, np);
  417. }
  418.  
  419. Command *BlankWindowStretcher::TrackMouse(TrackPhase atp, Point ap, Point pp, Point np)
  420. {
  421.     if (atp == eTrackPress) {
  422.     VObjectStretcher::TrackMouse(atp, ap, pp, np);
  423.     corner= Rectangle(oldRect.extent).PointToCorner(ap);
  424.     Point ppp= Rectangle(oldRect.extent).CornerToPoint(corner);
  425.     ((BlankWin*)vop)->SetMousePos(ppp);
  426.     // caution: because of SetMouse all following coordinates
  427.     //          are translated by ddd
  428.     ddd= ppp - ap;
  429.     return this;
  430.     }
  431.     return VObjectStretcher::TrackMouse(atp, ap, pp, np);
  432. }
  433.